home *** CD-ROM | disk | FTP | other *** search
/ A.C.E. 2 / ACE CD 2.iso / FILES / UTILS / GAMESDS3.DMS / GAMESDS3.adf / GDS_Examples.lha / Examples / bubble / bubble_scroll.c < prev    next >
C/C++ Source or Header  |  1994-11-14  |  18KB  |  576 lines
  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <string.h>
  4. #include <exec/memory.h>
  5. #include <exec/types.h>
  6. #include <graphics/gfx.h>
  7. #include <graphics/gfxbase.h>
  8.  
  9. #include <proto/exec.h>
  10. #include <proto/graphics.h>
  11. #include <proto/intuition.h>
  12.  
  13. #include "GameSmith:GameSmith.h"
  14. #include "GameSmith:include/libraries/libptrs.h"
  15.  
  16. #define WORDS         30
  17. #define RECTANGLES   100
  18.  
  19. #define BMWIDTH   1024
  20. #define BMHEIGHT   800
  21.  
  22. #define X_SPEED   7
  23. #define Y_SPEED   5
  24.  
  25. /*-------------------------------------------------------------------------*/
  26. /* Function Prototypes                                                      */
  27.  
  28. void scan_copper(void);
  29.  
  30. void scroll(void);
  31. void parser(int,char **);
  32. int setup(void);
  33. void rastport_demo(struct BitMap *);
  34. void copy_bitmap(struct BitMap *,struct BitMap *);
  35. void move_image(void);
  36. void check_bounds(void);
  37. void collision1(struct anim_struct *,struct anim_struct *,
  38.      struct collision_struct *,struct collision_struct *);
  39. int check_close(void);
  40. void cleanup(void);
  41. void free_arrays(void);
  42.  
  43. /*-------------------------------------------------------------------------*/
  44. /* some global variables                                                   */
  45.  
  46. int bubble_cnt,swidth,sheight,smode=0,delay=0,random_x=11,random_y=9;
  47. int *x=NULL,*y=NULL,*speedx=NULL,*speedy=NULL,*reset=NULL,*last=NULL;
  48. int dlist;
  49.  
  50. struct BitMap *bm3;
  51.  
  52. struct anim_struct *bubble;
  53. struct Interrupt *scroller=NULL;
  54.  
  55. /*-------------------------------------------------------------------------*/
  56.  
  57. struct gs_viewport vp =
  58.    {
  59.    NULL,                           /* ptr to next viewport */
  60.    NULL,                           /* ptr to color table */
  61.    0,                              /* number of colors in table */
  62.    NULL,                           /* ptr to user copper list (none) */
  63.    0,0,0,BMHEIGHT,BMWIDTH,         /* height, width, depth, bmheight, bmwidth */
  64.    0,0,                           /* top & left viewport offsets */
  65.    128,50,                        /* X & Y bitmap offsets */
  66.    GSVP_ALLOCBM,                  /* flags (alloc bitmaps, use display clip) */
  67.    NULL,NULL,                     /* 2.xx & above compatibility stuff */
  68.    NULL,NULL,                     /* bitmap pointers */
  69.    NULL,                           /* future expansion */
  70.    0,0,0,0                        /* display clip (use nominal) */
  71.    };
  72.  
  73. struct display_struct bubble_display =
  74.    {
  75.    NULL,                           /* ptr to previous display view */
  76.    NULL,NULL,                     /* 2.xx & above compatibility stuff */
  77.    0,0,                           /* X and Y display offsets (1.3 style) */
  78.    0,                              /* display mode ID */
  79.    4,4,                           /* sprite priorities (sprites in front of playfields) */
  80.    GSV_DOUBLE|GSV_SCROLLABLE,      /* flags (double buffered, scrollable) */
  81.    &vp,                           /* ptr to 1st viewport */
  82.    NULL                           /* future expansion */
  83.    };
  84.  
  85. /***************************************************************************/
  86.  
  87. main(argc,argv)
  88. int argc;
  89. char *argv[];
  90.  
  91. {
  92.    int err,end=0;
  93.  
  94.    if (argc < 2)
  95.       {
  96.       printf("\nUSAGE: bubbles [number of bubbles] [HIRES] [SUPER] [VB delay intervals] [X speed] [Y speed]\n");
  97.       exit(01);
  98.       }
  99.    if (gs_open_libs(DOS|GRAPHICS,0))   /* open AmigaDOS libs */
  100.       exit(01);               /* if can't open libs, abort */
  101.    parser(argc,argv);         /* parse command line args */
  102.    if (err=setup())            /* if couldn't get set up... abort program */
  103.       {
  104.       printf("\nSetup error: %d\n",err);
  105.       gs_close_libs();         /* close all libraries */
  106.       exit(02);
  107.       }
  108.    Forbid();                  /* take over the entire machine */
  109.    while (!end)               /* this shows off speed */
  110.       {
  111.       move_image();            /* move them bubbles around */
  112.       end=check_close();      /* end when user hits left mouse button */
  113.       }
  114.    Permit();                  /* OK, let other things run while we clean up */
  115.    cleanup();                  /* close & deallocate everything */
  116.    gs_close_libs();            /* close all libraries */
  117. }
  118.  
  119. /***************************************************************************/
  120.  
  121. void __interrupt __saveds scroll()
  122.  
  123. {
  124.    int stick,x=0,y=0,velocity=2,move;
  125.    static unsigned long timeout=0;
  126.    static int x_dir=0, y_dir=0;
  127.  
  128.    stick = gs_joystick(1);
  129.    if (stick & (JOY_LEFT|JOY_RIGHT|JOY_UP|JOY_DOWN))
  130.       {
  131.       if (stick & JOY_LEFT)
  132.          x=-(velocity+1);
  133.       else if (stick & JOY_RIGHT)
  134.          x=velocity+1;
  135.       if (stick & JOY_UP)
  136.          y=-velocity;
  137.       else if (stick & JOY_DOWN)
  138.          y=velocity;
  139.       if (stick & JOY_BUTTON1)
  140.          gs_scroll_vp_pf1(&bubble_display,0,x,y,1);/* scroll viewport 0, playefield 1, sync */
  141.       else
  142.          gs_scroll_vp(&bubble_display,0,x,y,1);      /* scroll viewport 0, synchronize */
  143.       timeout=0;
  144.       }
  145.    else
  146.       {
  147.       if (timeout++ >= (60*5))                  /* 5 second time out */
  148.          {
  149.          if (!x_dir)
  150.             {
  151.             x_dir=gs_random(X_SPEED)+1;
  152.             if (gs_random(100) < 50)
  153.                x_dir=-x_dir;
  154.             }
  155.          if (!y_dir)
  156.             {
  157.             y_dir=gs_random(Y_SPEED);
  158.             if (gs_random(100) < 50)
  159.                y_dir=-y_dir;
  160.             }
  161.          move=gs_scroll_vp(&bubble_display,0,x_dir,y_dir,1); /* scroll viewport 0, synchronize */
  162.          if (move & GSVP_PF1_RIGHT)
  163.             x_dir=-(gs_random(X_SPEED)+1);
  164.          else if (move & GSVP_PF1_LEFT)
  165.             x_dir=(gs_random(X_SPEED)+1);
  166.          if (move & GSVP_PF1_BOTTOM)
  167.             y_dir=-(gs_random(Y_SPEED)+1);
  168.          else if (move & GSVP_PF1_TOP)
  169.             y_dir=(gs_random(Y_SPEED)+1);
  170.          }
  171.       }
  172. }
  173.  
  174. /***************************************************************************/
  175.  
  176. void parser(argc,argv)
  177. int argc;
  178. char *argv[];
  179.  
  180. {
  181.    bubble_cnt=atoi(argv[1]);   /* # anims to place on the screen */
  182.    swidth=320;                  /* default width & height */
  183.    sheight=200;
  184. //   smode=0;                     /* default mode of lores no lace */
  185.    #ifdef NTSC_MONITOR_ID
  186.    smode=NTSC_MONITOR_ID;
  187.    #endif
  188.    if (argc >= 3)
  189.       {
  190.       if (!(stricmp(argv[2],"HIRES")))   /* check for hires spec */
  191.          {
  192.          swidth=640;
  193.          sheight=400;
  194.          smode|=HIRES|LACE;
  195.          }
  196.       else if (!(stricmp(argv[2],"SUPER")))   /* check for superhires */
  197.          {
  198.          if (GfxBase->LibNode.lib_Version >= 36)
  199.             {
  200.             #ifdef SUPER72_MONITOR_ID
  201.             if (ModeNotAvailable(SUPER72_MONITOR_ID | SUPERLACE_KEY))
  202.                {
  203.                swidth=640;
  204.                sheight=400;
  205.                smode=HIRES|LACE;
  206.                }
  207.             else
  208.                {
  209.                smode=SUPER72_MONITOR_ID | SUPERLACE_KEY;
  210.                swidth=800;
  211.                sheight=600;
  212.                }
  213.             #else
  214.             swidth=640;
  215.             sheight=400;
  216.             smode=HIRES|LACE;
  217.             #endif
  218.             }
  219.          else
  220.             {
  221.             swidth=640;
  222.             sheight=400;
  223.             smode=HIRES|LACE;
  224.             }
  225.          }
  226.       }
  227.    if (argc >= 4)
  228.       {
  229.       delay=atoi(argv[3]);      /* delay value in vertical blank intervals */
  230.       }
  231.    if (argc >= 5)               /* new random X speed range */
  232.       {
  233.       random_x=atoi(argv[4]);
  234.       if (random_x < 2)
  235.          random_x=2;
  236.       }
  237.    if (argc >= 6)               /* new random Y speed range */
  238.       {
  239.       random_y=atoi(argv[5]);
  240.       if (random_y < 2)
  241.          random_y=2;
  242.       }
  243. }
  244.  
  245. /***************************************************************************/
  246.  
  247. int setup()
  248.  
  249. {
  250.    int cnt,depth=0;
  251.    struct blit_struct *img;
  252.    struct anim_load_struct load;
  253.  
  254.    if (!(x=(int *)malloc(bubble_cnt*sizeof(int))))
  255.       return(-1);
  256.    if (!(y=(int *)malloc(bubble_cnt*sizeof(int))))
  257.       {
  258.       free_arrays();
  259.       return(-1);
  260.       }
  261.    if (!(speedx=(int *)malloc(bubble_cnt*sizeof(int))))
  262.       {
  263.       free_arrays();
  264.       return(-1);
  265.       }
  266.    if (!(speedy=(int *)malloc(bubble_cnt*sizeof(int))))
  267.       {
  268.       free_arrays();
  269.       return(-1);
  270.       }
  271.    if (!(last=(int *)malloc(bubble_cnt*sizeof(int))))
  272.       {
  273.       free_arrays();
  274.       return(-1);
  275.       }
  276.    if (!(reset=(int *)malloc(bubble_cnt*sizeof(int))))
  277.       {
  278.       free_arrays();
  279.       return(-1);
  280.       }
  281.    load.filename="bubble2";         /* name of anim file */
  282.    load.cmap_size=8;                  /* number of bits per color value */
  283.    load.array_elements=bubble_cnt;   /* number of array elements desired */
  284.    load.flags=0L;                     /* no special load flags */
  285.    if (gs_load_anim(&load))         /* load the anim object */
  286.       {
  287.       free_arrays();
  288.       return(-2);
  289.       }
  290.    bubble=load.anim_ptr.anim;         /* ptr to bubble anim */
  291.    if (load.type)                     /* make sure it's an anim type */
  292.       {
  293.       FreeMem(load.cmap,load.cmap_entries*sizeof(long));
  294.       free_arrays();
  295.       if (load.type = 1)
  296.          gs_free_cplx((struct anim_cplx *)bubble,bubble_cnt);
  297.       return(-3);
  298.       }
  299.    img = bubble[0].list;            /* ptr to 1st image in anim sequence */
  300.    while (img)                        /* find max depth of anim */
  301.       {
  302.       if (img->depth > depth)
  303.          depth = img->depth;
  304.       if (img->next == img)         /* avoid infinite loop */
  305.          img=NULL;                  /* if single shot anim */
  306.       else
  307.          img=img->next;
  308.       }
  309.    vp.height = sheight;               /* set up display dimensions */
  310.    vp.width = swidth;
  311.    vp.depth = depth;
  312.    bubble_display.modes = smode;
  313.    vp.num_colors=load.cmap_entries;
  314.    vp.color_table=load.cmap;         /* addr of color table */
  315.    if (gs_create_display(&bubble_display))
  316.       {
  317.       FreeMem(load.cmap,load.cmap_entries*sizeof(long));
  318.       free_arrays();
  319.       gs_free_anim(bubble,bubble_cnt);
  320.       return(-6);
  321.       }
  322.    FreeMem(load.cmap,load.cmap_entries*sizeof(long));   /* done with color table */
  323.    if ((dlist=gs_get_display_list()) < 0)
  324.       {
  325.       free_arrays();
  326.       gs_free_anim(bubble,bubble_cnt);
  327.       return(-8);
  328.       }
  329.    bm3=gs_get_bitmap(vp.depth,vp.bmwidth,vp.bmheight,0);
  330.    gs_init_anim(dlist,vp.bitmap1,vp.bitmap2,NULL);   /* tell anim system about bitmaps */
  331.    gs_random(0);                     /* seed random function */
  332.    gs_set_anim_bounds(dlist,0,0,BMWIDTH-1,BMHEIGHT-1);   /* set bounds for anim objects */
  333.    gs_set_collision(dlist,&collision1);   /* set ptr to collision handler */
  334.    for (cnt=0; cnt < bubble_cnt; cnt++)
  335.       {                              /* add all bubbles to a display list */
  336.       reset[cnt]=0;
  337.       last[cnt]=-1;
  338.       x[cnt] = gs_random(BMWIDTH);   /* random X,Y coords */
  339.       y[cnt] = gs_random(BMHEIGHT);
  340.       while ((speedx[cnt] = gs_random(random_x)) == 0);
  341.       while ((speedy[cnt] = gs_random(random_y)) == 0);
  342.       if (cnt&1)
  343.          {
  344.          speedx[cnt]=-speedx[cnt];
  345.          speedy[cnt]=-speedy[cnt];
  346.          }
  347.       if (bm3)                        /* if restore bitmap */
  348.          {
  349.          bubble[cnt].flags|=ANIM_SAVE_BG;   /* use fastest display method (next to simple copy) */
  350.          if (bubble[cnt].flags & ANIM_CLEAR)
  351.             bubble[cnt].flags ^= ANIM_CLEAR;
  352.          if (bubble[cnt].flags & ANIM_COPY)
  353.             bubble[cnt].flags ^= ANIM_COPY;
  354.          }
  355.       if (gs_add_anim(dlist,&bubble[cnt],x[cnt],y[cnt]))
  356.          {
  357.          cleanup();                  /* release everything */
  358.          return(-8);                  /* return failure */
  359.          }
  360.       gs_set_anim_cell(&bubble[cnt],gs_random(bubble[cnt].count));
  361.       }
  362.    rastport_demo(vp.bitmap1);         /* alloc rastport & draw some stuff */
  363.    copy_bitmap(vp.bitmap1,vp.bitmap2);   /* copy bitmap 1 to bitmap 2 */
  364.    gs_draw_anims(dlist);
  365.    check_bounds();
  366.    gs_next_anim_page(dlist);
  367.    gs_show_display(&bubble_display,1);
  368.    gs_flip_display(&bubble_display,1);
  369.    gs_open_vb_timer();
  370.    scroller=gs_add_vb_server(&scroll,0);
  371.    if (!scroller)
  372.       {
  373.       cleanup();
  374.       return(-7);
  375.       }
  376.    return(0);
  377. }
  378.  
  379. /***************************************************************************/
  380.  
  381. void rastport_demo(bitmap)
  382. struct BitMap *bitmap;
  383.  
  384. {
  385.    struct RastPort rastport = {0};
  386.    int cnt,x,y,width,height;
  387.  
  388.    InitRastPort(&rastport);         /* initialize rastport */
  389.    rastport.BitMap=bitmap;            /* tell rastport to use our bitmap */
  390.    SetDrMd(&rastport,JAM1);
  391.    for (cnt=0; cnt < RECTANGLES; cnt++)
  392.       {
  393.       SetAPen(&rastport,gs_random(1<<bitmap->Depth)+1);   /* select pen color */
  394.       width=gs_random(BMWIDTH/2);
  395.       height=gs_random(BMHEIGHT/2);
  396.       x=gs_random(BMWIDTH-width);
  397.       y=gs_random(BMHEIGHT-height);
  398.       RectFill(&rastport,x,y,x+width,y+height);
  399.       }
  400.    for (cnt=0; cnt < WORDS; cnt++)
  401.       {
  402.       SetAPen(&rastport,gs_random(1<<bitmap->Depth)+1);   /* select pen color */
  403.       /*
  404.       NOTE: below you should replace "80" with the width of the font times the
  405.       width of the string (10 chars in this case).  Then you should replace the
  406.       "16" with the font height, and the "15" with the font height - 1.
  407.       */
  408.       Move(&rastport,gs_random(BMWIDTH-80),gs_random(BMHEIGHT-16)+15); /* position drawing pen */
  409.       Text(&rastport,"GameSmith!",10);   /* print some text */
  410.       }
  411. }
  412.  
  413. /***************************************************************************/
  414.  
  415. void copy_bitmap(bm1,bm2)
  416. struct BitMap *bm1,*bm2;
  417.  
  418. {
  419.    int cnt;
  420.  
  421. /* 
  422.    NOTE: gs_blit_memcopy is the only "blit" function that DOESN'T have a
  423.    CPU version.  A memory copy operation using the CPU is obviously an
  424.    incredibly trivial task.  The gs_blit_memcopy function can only operate
  425.    on Chip RAM since it uses the blitter chip.
  426. */
  427.  
  428.    for (cnt=0; cnt < bm1->Depth; cnt++)
  429.       {
  430.       gs_blit_memcopy(bm1->Planes[cnt],bm2->Planes[cnt],
  431.          (bm1->BytesPerRow/2)*bm1->Rows);
  432.       }
  433. }
  434.  
  435. /***************************************************************************/
  436.  
  437. void move_image()
  438.  
  439. /* move and animate the graphic objects on the screen */
  440.  
  441. {
  442.    int cnt;
  443.  
  444.    if (gs_vb_time() < delay)
  445.       return;
  446.    gs_vb_timer_reset();
  447.    for (cnt=0; cnt < bubble_cnt; cnt++)
  448.       {
  449.       x[cnt]+=speedx[cnt];            /* move the object */
  450.       y[cnt]+=speedy[cnt];
  451.       gs_anim_obj(&bubble[cnt],x[cnt],y[cnt]);
  452.       if (reset[cnt])               /* since anim doesn't loop, must reset */
  453.          {                           /* the sequence in the event of collision */
  454.          reset[cnt]=0;               /* start at 1st cell in anim sequence */
  455.          gs_set_anim_cell(&bubble[cnt],0);
  456.          }
  457.       if (!bubble[cnt].collide)      /* if not colliding, clear last ptr */
  458.          last[cnt]=-1;
  459.       }
  460.    while (bubble_display.flags & GSV_FLIP);   /* while page not flipped yet */
  461.    gs_draw_anims(dlist);            /* draw them anim objects! */
  462.    check_bounds();                  /* bounce off of outer bitmap bounds */
  463.    gs_next_anim_page(dlist);         /* tell anim sys to use other bitmap */
  464.    gs_flip_display(&bubble_display,1);   /* switch to other display, sync */
  465. }
  466.  
  467. /***************************************************************************/
  468.  
  469. void check_bounds()
  470.  
  471. {
  472.    int cnt;
  473.  
  474.    for (cnt=0; cnt < bubble_cnt; cnt++)
  475.       {
  476.       if (bubble[cnt].flags & (ANIM_BOUNDS_X1|ANIM_BOUNDS_X2))
  477.          {
  478.          x[cnt]=bubble[cnt].x;   /* keep track of current location */
  479.          speedx[cnt]=-speedx[cnt];   /* reverse X direction */
  480.          reset[cnt]=1;            /* make bubble warp */
  481.          last[cnt]=-1;            /* no colliding */
  482.          }
  483.       if (bubble[cnt].flags & (ANIM_BOUNDS_Y1|ANIM_BOUNDS_Y2))
  484.          {
  485.          y[cnt]=bubble[cnt].y;
  486.          speedy[cnt]=-speedy[cnt];   /* reverse Y direction */
  487.          reset[cnt]=1;
  488.          last[cnt]=-1;
  489.          }
  490.       }
  491. }
  492.  
  493. /***************************************************************************/
  494.  
  495. int check_close()
  496.  
  497. /* check for user input */
  498.  
  499. {
  500.    if (gs_joystick(0) & (JOY_BUTTON1|JOY_BUTTON2))
  501.       return(1);
  502.    return(0);
  503. }
  504.  
  505. /***************************************************************************/
  506.  
  507. void collision1(anim1,anim2,coll1,coll2)
  508. struct anim_struct *anim1;
  509. struct anim_struct *anim2;
  510. struct collision_struct *coll1;
  511. struct collision_struct *coll2;
  512.  
  513. /*
  514.  
  515. This is the collision handler which makes the bubbles "bounce" off of
  516. each other.
  517.  
  518. */
  519.  
  520. {
  521.    int temp;
  522.  
  523.    if (last[anim1->array_num] != anim2->array_num)      /* if not same object */
  524.       {
  525.       last[anim1->array_num] = anim2->array_num;      /* remember last collision */
  526.       last[anim2->array_num] = anim1->array_num;
  527.       reset[anim1->array_num]=1;                        /* reset anim cell */
  528.       reset[anim2->array_num]=1;
  529.       temp=speedy[anim2->array_num];                  /* swap values */
  530.       speedy[anim2->array_num]=speedy[anim1->array_num];
  531.       speedy[anim1->array_num]=temp;
  532.       temp=speedx[anim2->array_num];
  533.       speedx[anim2->array_num]=speedx[anim1->array_num];
  534.       speedx[anim1->array_num]=temp;
  535.       }
  536. }
  537.  
  538. /***************************************************************************/
  539.  
  540. void cleanup()
  541.  
  542. /* release all resources and memory */
  543.  
  544. {
  545.    if (scroller)
  546.       gs_remove_vb_server(scroller);
  547.    free_arrays();
  548.    gs_free_anim(bubble,bubble_cnt);
  549.    gs_remove_display(&bubble_display);
  550.    gs_free_display_list(dlist);
  551.    gs_close_vb_timer();
  552. }
  553.  
  554. /***************************************************************************/
  555.  
  556. void free_arrays()
  557.  
  558. /* release memory used by control arrays */
  559.  
  560. {
  561.    if (x)
  562.       free(x);
  563.    if (y)
  564.       free(y);
  565.    if (speedx)
  566.       free(speedx);
  567.    if (speedy)
  568.       free(speedy);
  569.    if (last)
  570.       free(last);
  571.    if (reset)
  572.       free(reset);
  573.    if (bm3)
  574.       gs_free_bitmap(bm3);
  575. }
  576.